Objectifs du cours
- Qu'est-ce que R et quelles possibilités sont offertes par ce langage ?
- Quand y avoir recours est-il pertinent dans le cadre de ma recherche ?
- Où se trouvent les ressources pour l'utiliser ?
12 février 2018
Le document possédant l'extension ".Rmd" est au format markdown (comme wikipedia) et peut être annoté en tout temps.
N'hésitez pas à prendre vos notes directement dans ce document.
Quelques ressources utiles
Computational Historical Thinking With Applications in R de Lincoln A. Mullen (incomplet)
http://dh-r.lincolnmullen.com/
Le syllabus de son cours.
http://lincolnmullen.com/courses/clio2.2018/
The Historian's Macroscope: Big Digital History de Shawn Graham, Ian Milligan et Scott Weingart
http://www.themacroscope.org/?page_id=707
Le livre a été publié depuis, voir http://www.themacroscope.org/2.0/
Une ressource en français.
Introduction à R et au tidyverse de Julien Barnier
R for Data Science de Garrett Grolemund & Hadley Wickham
An Introduction to Statistical and Data Sciences via R de Chester Ismay & Albert Y. Kim
Excel vs R: A Brief Introduction to R
https://www.jessesadler.com/post/excel-vs-r/
The Programming Historian
Les cheatsheets de RStudio
Qu'est-ce que R ?
R est un langage de programmation à l'origine prévu pour faire de l'analyse statistique.
R est disponible sous licence libre. Il est basé sur le langage propriétaire S.
Son usage s'est répandu bien au-delà des statistiques.
Mais R désigne également une interface de programmation que l'on nomme R GUI, "GUI" signifiant "Graphical User Interface".
R GUI est un logiciel libre.
Qu'est-ce que RStudio ?
RStudio est un environnement permettant de programmer en R, c'est-à-dire un peu plus qu'une simple interface graphique.
En plus d'afficher une console (là où le code est exécuté, généralement dans la fenêtre en bas à gauche) et une fenêtre de script (là où l'on rédige le code que l'on veut réutiliser, généralement en haut à gauche), RStudio permet par exemple de conserver bien en vue la liste des variables enregistrées en mémoire (en haut à droite), ou d'accéder aisément à des fichiers d'aide (en bas à droite).
RStudio permet également d'utiliser un notebook comme celui-ci.
Comment fonctionnent les notebooks ?
Ce document que vous avez ouvert dans RStudio ou dans un navigateur web est un notebook.
C'est un format de document permettant de présenter du texte, du code, et les résultats de l'exécution du code.
Dans la recherche scientifique, ce format permet de répliquer une expérience.
La démarche de partager un notebook en même temps qu'un article scientifique devrait à l'avenir devenir un standard.
Le système de notebooks le plus répandu est Jupyter, qui fonctionne avec les langages de programmation Julia, Python et R, mais permet aussi de gérer d'autres langages de programmation.
Ici, nous utilisons des notebooks au format prévu par RStudio.
Un notebook peut se décliner en plusieurs formats.
- Le fichier au format
.Rmds'ouvre dans RStudio. - Le fichier au format
.nb.htmls'ouvre dans un navigateur. - Le fichier au format
.htmlcontient les slides (dans le cas présent).
Le code apparaît systématiquement dans une case sur fond gris.
Le résultat du code apparaît ensuite dans une case sur fond blanc ou gris selon les réglages.
for (i in 1:3) print(LETTERS[i])
## [1] "A" ## [1] "B" ## [1] "C"
En ouvrant le notebook dans RStudio, vous aurez la possibilité de modifier le code et de le réexécuter.
Par exemple, dans le code ci-dessous, nous sauvons la valeur "2" dans la variable "a" et la valeur "e" dans la variable "b". Puis nous élevons a à la puissance b, c'est-à-dire 2 à la puissance 3.
Le résultat s'affiche en-dessous.
a <- 2 b <- 3 a^b
## [1] 8
Exercice 1.1
- Reprenez l'exemple contenant du code ci-dessus.
- Modifiez les valeurs de a et de b (par exemple avec a = 10 et b = -1).
- Actualisez le calcul.
Obtenir de l'aide…
… quand on connaît le nom de la fonction.
help(exp) ## La page d'aide d'une variable ?exp ## Une autre syntaxe pour le même résultat
La touche de tabulation est utile dans le cas où les premières lettres d'une fonction sont connues.
… quand on ne connaît pas le nom de la fonction mais seulement celui de la méthode.
help.search("linear model") ## Chercher dans les pages d'aide
??"linear model" ## Une autre syntaxe pour le même résultat
Dans ce notebook comme dans les scripts que vous trouverez en ligne, les fonctions peuvent sembler sortir d'un chapeau comme si de rien n'était.
Ne pas se faire d'illusions:
- Il a d'abord fallu découvrir leur existence.
- Puis comprendre leur fonctionnement.
- (Le plus souvent) en faisant des erreurs au passage.
C'est pour cette raison qu'il ne faut jamais hésiter à faire une recherche
- dans les pages d'aide de R
- avec
?lorsqu'on connaît la fonction. - avec
??lorsqu'on ne la connaît pas. - en ligne
- sur stackoverflow
- sur un moteur de recherche
Autres ressources en ligne (veille)
- Sur Twitter, le hashtag #Rstats
- Sur R-blogger, un agrégateur de blogs dont le thème est le langage R https://www.r-bloggers.com/
- Sur les mailing lists https://www.r-project.org/mail.html
Exercice 1.2
- Calculez l'exponentielle de
b(en anglais : "exponential"). - Calculez la racine carrée de
a(en anglais : "square root").
La cheatsheet pour l'importation et l'exportation de données.
https://github.com/rstudio/cheatsheets/raw/master/data-import.pdf
Les fonctions
Une fonction prédéfinie.
y = sqrt(4) ## Fonction racine carrée y
## [1] 2
Toutes les fonctions du package base.
help(package="base")
Une fonction construite pour l'occasion.
f <- function(x) {2*x}
f(17)
## [1] 34
f(pi)
## [1] 6.283185
Les classes
- "character"
- "complex"
- "double"
- "expression"
- "integer"
- "list"
- "logical"
- "numeric"
- "single"
- "raw"
- "vector"
- "function"
- …
Connaître la classe d'un objet.
z <- "hello" class(z) ## Le type d'une variable
## [1] "character"
La fonction str permet d'obtenir des informations plus complètes.
str(z)
## chr "hello"
vec <- c(3,5,3,7) str(vec)
## num [1:4] 3 5 3 7
f <- function(x) {2*x}
str(f)
## function (x) ## - attr(*, "srcref")=Class 'srcref' atomic [1:8] 1 6 1 22 6 22 1 1 ## .. ..- attr(*, "srcfile")=Classes 'srcfilecopy', 'srcfile' <environment: 0x7f89b07d8748>
a <- f(17) str(a)
## num 34
Chaînes de caractères
Les chaînes de caractères sont des assemblages de symboles.
b <- "unil" b
## [1] "unil"
Il existe de nombreuses fonctions pour les manipuler.
Par exemple pour connaître leur longueur.
nchar(b)
## [1] 4
Pour manipuler du texte de manière avancée dans R (ou dans n'importe quel autre langage de programmation), il peut être nécessaire d'apprendre à manipuler des expressions régulières.
Deux tutoriaux pour R.
La cheatsheet, indispensable.
https://github.com/rstudio/cheatsheets/raw/master/strings.pdf
Pour tester des expressions régulières :
Quelques ressources ludiques pour s'entraîner…
Les éléments logiques
- TRUE et FALSE
Mais aussi…
- NA, NaN
- Inf
"NA" signifie "Not available".
"NaN" signifie "Not a Number".
Les opérateurs de comparaison
1 == 1
## [1] TRUE
1 == 2
## [1] FALSE
1 != 1
## [1] FALSE
1 != 2
## [1] TRUE
1 < 1
## [1] FALSE
1 <= 1
## [1] TRUE
Les vecteurs
x <- c(5,4,5,6,7,8) x
## [1] 5 4 5 6 7 8
x_char = c("a","b","c")
x_char
## [1] "a" "b" "c"
Accéder directement à un élément d'un vecteur
x
## [1] 5 4 5 6 7 8
x[2]
## [1] 4
x[c(2,4)]
## [1] 4 6
x
## [1] 5 4 5 6 7 8
x[c(-2,-4)]
## [1] 5 5 7 8
Manipuler des vecteurs
x[6] = 10 x
## [1] 5 4 5 6 7 10
a = c(3,4,5,6) a[c(2,3)] = 0 a
## [1] 3 0 0 6
a[c(2,3)] = c(8,7) a
## [1] 3 8 7 6
c(1,2,3) + c(3,4,5)
## [1] 4 6 8
4 * c(1,2,3)
## [1] 4 8 12
c(2,5) < 4
## [1] TRUE FALSE
Attention lorsque deux éléments ne sont pas de même taille !
c(1,2) + c(3,4,5,6)
## [1] 4 6 6 8
Attention lorsque l'un n'est pas multiple de l'autre !
c(1,2) + c(2,3,4)
## Warning in c(1, 2) + c(2, 3, 4): longer object length is not a multiple of ## shorter object length
## [1] 3 5 5
Comment connaître le type d'une variable ?
a <- 1 b <- 1:5 class(a)
## [1] "numeric"
class(b)
## [1] "integer"
c <- "hello" d <- 1 > 2 class(c)
## [1] "character"
class(d)
## [1] "logical"
Quelle est la "taille" de l'objet ?
length(a)
## [1] 1
length(b)
## [1] 5
length(c)
## [1] 1
length(d)
## [1] 1
Manipulations de l'environnement
ls() ## Les variables sauvées dans l'environnement de travail
## [1] "a" "b" "c" "d" "f" "i" "vec" ## [8] "x" "x_char" "y" "z"
rm(y) ## On retire la variable "y" ls()
## [1] "a" "b" "c" "d" "f" "i" "vec" ## [8] "x" "x_char" "z"
Exercice 2
- Créez un vecteur avec les cinq valeurs suivantes: 5, 10, 15, 20 et 25.
- Cherchez quelle fonction permet de calculer la moyenne («mean» en anglais) d'une distribution.
- Calculez-la :-)
Le package readr
À partir de là, nous allons utiliser le package readr pour lire et écrire des informations textuelles.
Le code suivant vérifie si le package est installé sur votre machine et l'installe le cas échéant. Puis il le charge.
if (!require(readr)) install.packages("readr")
## Loading required package: readr
library(readr)
- Les packages sont des ensembles de fonctions que l'on ajoute aux fonctions déjà disponibles.
- Les fonctions d'un package ont en général été regroupées autour d'une thématique commune.
- Dans le cas de readr: l'importation et l'exportation de données textuelles.
Pour l'exercice, nous allons utiliser un jeu de données avec une licence ouverte, trouvé sur le site data.gouv.fr
https://www.data.gouv.fr/fr/datasets/indices-mensuels-de-retard-des-bus/#_
csv (comma separated values)
Tout d'abord, il faut sauver le fichier dans le dossier de travail ("ENS-DH-R" dans notre cas).
Puis, pour l'importer, il ne faut pas oublier les guillemets autour du nom du fichier.
retards <- read_csv2("indices-mensuels-de-retard-des-bus.csv")
## Using ',' as decimal and '.' as grouping mark. Use read_delim() for more control.
## Parsed with column specification: ## cols( ## .default = col_number(), ## Mois = col_character(), ## `Citadine Halluin` = col_character(), ## Z1 = col_character() ## )
## See spec(...) for full column specifications.
Il est important de lire les commentaires (souvent indiqués en rouge, comme les erreurs… malin).
Un aperçu de ce que nous avons importé.
retards
## # A tibble: 11 x 60 ## Mois `Citadine Tourcoing` `Citadine Roubaix` `Citadine Lille` ## <chr> <dbl> <dbl> <dbl> ## 1 08. Aout 106 65 91 ## 2 09. Septembre 109 93 148 ## 3 10. Octobre 102 93 95 ## 4 11. Novembre 109 117 109 ## 5 03. Mars 104 123 83 ## 6 07. Juillet 141 81 76 ## 7 02. Février 126 142 95 ## 8 04. Avril 92 89 78 ## 9 05. Mai 94 11 73 ## 10 01. Janvier 141 163 66 ## 11 06. Juin 157 110 106 ## # ... with 56 more variables: MWR <dbl>, COR <dbl>, `Citadine ## # Armentières` <dbl>, `Citadine Halluin` <chr>, L1 <dbl>, L2 <dbl>, ## # L3 <dbl>, L4 <dbl>, L90 <dbl>, L91 <dbl>, Z1 <chr>, Z2 <dbl>, ## # Z3 <dbl>, Z4 <dbl>, `10` <dbl>, `11` <dbl>, `12` <dbl>, `13` <dbl>, ## # `14` <dbl>, `15` <dbl>, `16` <dbl>, `17` <dbl>, `18` <dbl>, ## # `30` <dbl>, `32` <dbl>, `33` <dbl>, `35` <dbl>, `36` <dbl>, ## # `37` <dbl>, `50` <dbl>, `51` <dbl>, `52` <dbl>, `53` <dbl>, ## # `54` <dbl>, `55` <dbl>, `57` <dbl>, `58` <dbl>, `59` <dbl>, ## # `56` <dbl>, `61` <dbl>, `63` <dbl>, `64` <dbl>, `65` <dbl>, ## # `66` <dbl>, `67` <dbl>, `75` <dbl>, `76` <dbl>, `78` <dbl>, ## # `79` <dbl>, `80` <dbl>, `81` <dbl>, `82` <dbl>, `84` <dbl>, ## # `86` <dbl>, `87` <dbl>, `88` <dbl>
Un autre type d'aperçu.
str(retards)
## Classes 'tbl_df', 'tbl' and 'data.frame': 11 obs. of 60 variables: ## $ Mois : chr "08. Aout" "09. Septembre" "10. Octobre" "11. Novembre" ... ## $ Citadine Tourcoing : num 106 109 102 109 104 141 126 92 94 141 ... ## $ Citadine Roubaix : num 65 93 93 117 123 81 142 89 11 163 ... ## $ Citadine Lille : num 91 148 95 109 83 76 95 78 73 66 ... ## $ MWR : num 211 213 149 78 72 213 103 90 170 87 ... ## $ COR : num 113 171 176 201 138 173 121 146 164 129 ... ## $ Citadine Armentières: num 29 20 18 20 41 67 135 44 48 36 ... ## $ Citadine Halluin : chr "1.0" "4.3" "6.8" "1.9" ... ## $ L1 : num 121 162 120 119 106 158 104 98 110 97 ... ## $ L2 : num 40 78 62 55 71 55 62 54 65 57 ... ## $ L3 : num 96 121 50 64 43 87 48 58 54 65 ... ## $ L4 : num 143 208 141 181 154 171 129 134 162 165 ... ## $ L90 : num 51 64 60 66 56 99 42 48 64 56 ... ## $ L91 : num 64 111 87 130 79 119 93 87 114 76 ... ## $ Z1 : chr "0.8" "2.9" "1.8" "1.9" ... ## $ Z2 : num 30 43 48 65 15 24 17 20 18 22 ... ## $ Z3 : num 13 24 47 43 38 31 34 17 47 55 ... ## $ Z4 : num 94 34 22 39 19 148 15 10 20 29 ... ## $ 10 : num 89 106 114 134 109 123 105 118 108 115 ... ## $ 11 : num 58 105 113 119 75 78 70 77 114 98 ... ## $ 12 : num 137 218 206 157 129 181 120 136 169 122 ... ## $ 13 : num 50 93 76 114 89 91 75 80 91 90 ... ## $ 14 : num 193 232 208 222 147 243 156 143 141 127 ... ## $ 15 : num 77 129 131 163 111 61 125 119 118 132 ... ## $ 16 : num 95 139 146 162 119 91 110 91 131 157 ... ## $ 17 : num 133 119 88 85 77 130 56 71 101 78 ... ## $ 18 : num 167 195 193 190 177 139 131 153 176 200 ... ## $ 30 : num 115 167 132 142 100 107 109 81 122 106 ... ## $ 32 : num 84 98 94 89 101 149 76 84 99 92 ... ## $ 33 : num 58 110 105 106 146 71 86 89 94 123 ... ## $ 35 : num 56 148 128 126 118 91 139 99 131 124 ... ## $ 36 : num 62 66 46 57 40 70 46 50 48 68 ... ## $ 37 : num 125 153 76 71 71 116 61 76 74 77 ... ## $ 50 : num 72 101 122 153 94 106 77 94 91 91 ... ## $ 51 : num 43 41 50 45 33 33 43 37 32 34 ... ## $ 52 : num 42 79 130 114 67 69 84 76 70 71 ... ## $ 53 : num 99 126 85 93 72 89 97 61 93 89 ... ## $ 54 : num 118 117 100 140 83 108 87 67 98 88 ... ## $ 55 : num 95 115 130 155 98 112 99 93 102 94 ... ## $ 57 : num 80 129 101 132 126 93 94 91 126 104 ... ## $ 58 : num 73 156 116 117 92 85 96 78 86 114 ... ## $ 59 : num 26 47 50 62 38 37 37 45 40 55 ... ## $ 56 : num 33 66 76 108 74 88 101 83 71 77 ... ## $ 61 : num 54 57 77 95 24 54 55 27 34 66 ... ## $ 63 : num 60 67 113 85 53 99 97 70 51 63 ... ## $ 64 : num 93 63 68 70 43 112 37 35 51 41 ... ## $ 65 : num 13 50 63 55 15 29 20 16 64 48 ... ## $ 66 : num 44 44 47 39 56 50 50 47 41 44 ... ## $ 67 : num 39 61 36 40 45 27 34 33 37 22 ... ## $ 75 : num 54 66 43 73 22 20 26 36 84 82 ... ## $ 76 : num 46 47 39 44 21 21 14 22 24 24 ... ## $ 78 : num NA 87 67 68 37 67 21 21 49 60 ... ## $ 79 : num 41 50 60 76 53 59 83 45 46 78 ... ## $ 80 : num 53 61 44 75 64 58 61 61 60 63 ... ## $ 81 : num 53 78 64 85 45 55 50 57 30 36 ... ## $ 82 : num 80 90 93 96 81 110 92 70 93 72 ... ## $ 84 : num 57 59 51 72 67 59 74 57 72 78 ... ## $ 86 : num 72 108 87 78 58 112 52 63 101 60 ... ## $ 87 : num 37 64 55 64 70 32 62 41 64 82 ... ## $ 88 : num 29 49 65 88 44 62 39 68 59 43 ... ## - attr(*, "spec")=List of 2 ## ..$ cols :List of 60 ## .. ..$ Mois : list() ## .. .. ..- attr(*, "class")= chr "collector_character" "collector" ## .. ..$ Citadine Tourcoing : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ Citadine Roubaix : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ Citadine Lille : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ MWR : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ COR : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ Citadine Armentières: list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ Citadine Halluin : list() ## .. .. ..- attr(*, "class")= chr "collector_character" "collector" ## .. ..$ L1 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ L2 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ L3 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ L4 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ L90 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ L91 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ Z1 : list() ## .. .. ..- attr(*, "class")= chr "collector_character" "collector" ## .. ..$ Z2 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ Z3 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ Z4 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 10 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 11 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 12 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 13 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 14 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 15 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 16 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 17 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 18 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 30 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 32 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 33 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 35 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 36 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 37 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 50 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 51 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 52 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 53 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 54 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 55 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 57 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 58 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 59 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 56 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 61 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 63 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 64 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 65 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 66 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 67 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 75 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 76 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 78 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 79 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 80 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 81 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 82 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 84 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 86 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 87 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## .. ..$ 88 : list() ## .. .. ..- attr(*, "class")= chr "collector_number" "collector" ## ..$ default: list() ## .. ..- attr(*, "class")= chr "collector_guess" "collector" ## ..- attr(*, "class")= chr "col_spec"
Pour consulter l'objet importé - dans ce cas un tableau de données - vous pouvez vous rendre dans la fenêtre en haut à droite de RStudio puis dans l'onglet "Environment". Vous trouverez le tableau sous "Data". En double-cliquant dessus, il s'ouvrira dans cette fenêtre et vous pourrez vérifier que le tableau a bien été importé.
Pour sauver un fichier au format csv, il faut utiliser la fonction write_csv
## write_csv(retards, "retards.csv")
xls (Microsoft Excel/libreOffice/Google Spreadsheets)
- On préfère en général sauver les fichiers au format csv ou json car ils sont ainsi beaucoup plus légers et ne transportent pas l'encodage parfois lourd d'un fichier xls.
- Néanmoins, ce n'est pas toujours possible d'y échapper lors d'une importation.
- Si possible, exporter depuis Excel ou LibreOffice vos données au format csv (pour "comma separated values")
- Sinon…
readxl est un package qui permet d'importer (et d'exporter) des fichiers au format xls.
if (!require(readxl)) install.packages("readxl")
## Loading required package: readxl
library(readxl)
Prenons un fichier au hasard de l'OFS : "Comportement de la population en matière de transport, chiffres clés - agglomération de Lausanne (définition 2000)"
Il est présent dans le dossier.
La fonction read_excel est ce qu'il nous faut.
aie <- read_excel("su-f-11.04.03-MZ-2015-A2_5586_Def2000.xls")
aie
## # A tibble: 39 x 55 ## `Comportement de la population en matière de transport, chiffres clés 2015 - agglomération de Lausanne (définition 2000)` ## <chr> ## 1 Disponibilité d'une voiture, possession de permis et d'abonnement, taux de ## 2 <NA> ## 3 <NA> ## 4 <NA> ## 5 Total ## 6 Sexe ## 7 Hommes ## 8 Femmes ## 9 Âge ## 10 6-17 ans ## # ... with 29 more rows, and 54 more variables: X__1 <chr>, X__2 <chr>, ## # X__3 <chr>, X__4 <chr>, X__5 <chr>, X__6 <chr>, X__7 <chr>, ## # X__8 <chr>, X__9 <chr>, X__10 <chr>, X__11 <chr>, X__12 <chr>, ## # X__13 <chr>, X__14 <chr>, X__15 <chr>, X__16 <chr>, X__17 <chr>, ## # X__18 <chr>, X__19 <chr>, X__20 <chr>, X__21 <chr>, X__22 <chr>, ## # X__23 <chr>, X__24 <chr>, X__25 <chr>, X__26 <chr>, X__27 <chr>, ## # X__28 <chr>, X__29 <chr>, X__30 <chr>, X__31 <chr>, X__32 <chr>, ## # X__33 <chr>, X__34 <chr>, X__35 <chr>, X__36 <chr>, X__37 <chr>, ## # X__38 <chr>, X__39 <chr>, X__40 <chr>, X__41 <chr>, X__42 <chr>, ## # X__43 <chr>, X__44 <chr>, X__45 <chr>, X__46 <chr>, X__47 <chr>, ## # X__48 <chr>, X__49 <chr>, X__50 <chr>, X__51 <chr>, X__52 <chr>, ## # X__53 <chr>, X__54 <chr>
Toutes les entrées sont considérées comme des chaînes de caractères.
str(aie)
## Classes 'tbl_df', 'tbl' and 'data.frame': 39 obs. of 55 variables: ## $ Comportement de la population en matière de transport, chiffres clés 2015 - agglomération de Lausanne (définition 2000): chr "Disponibilité d'une voiture, possession de permis et d'abonnement, taux de mobilité, distance journalière, durée moyenne des dé"| __truncated__ NA NA NA ... ## $ X__1 : chr NA "Outils de transport" "Disponibilité d'une voiture" "[%]" ... ## $ X__2 : chr NA NA NA "+/-" ... ## $ X__3 : chr NA NA "Possession du permis de conduire" "[%]" ... ## $ X__4 : chr NA NA NA "+/-" ... ## $ X__5 : chr NA NA "Possession d'abonnements des TP" "[%]" ... ## $ X__6 : chr NA NA NA "+/-" ... ## $ X__7 : chr NA "Taux de mobilité" "Personnes mobiles le jour de référence (en déplacement)" "[%]" ... ## $ X__8 : chr NA NA NA "+/-" ... ## $ X__9 : chr NA "Distance journalière moyenne" "Total" "[km]" ... ## $ X__10 : chr NA NA NA "+/-" ... ## $ X__11 : chr NA NA "Mobilité douce" "[km]" ... ## $ X__12 : chr NA NA NA "+/-" ... ## $ X__13 : chr NA NA "Transport individuel motorisé" "[km]" ... ## $ X__14 : chr NA NA NA "+/-" ... ## $ X__15 : chr NA NA "Transports publics" "[km]" ... ## $ X__16 : chr NA NA NA "+/-" ... ## $ X__17 : chr NA NA "Travail" "[km]" ... ## $ X__18 : chr NA NA NA "+/-" ... ## $ X__19 : chr NA NA "Loisirs" "[km]" ... ## $ X__20 : chr NA NA NA "+/-" ... ## $ X__21 : chr NA "Durée moyenne des déplacements (sans les temps d'attente et de correspondance)" "Total" "[min.]" ... ## $ X__22 : chr NA NA NA "+/-" ... ## $ X__23 : chr NA NA "Mobilité douce" "[min.]" ... ## $ X__24 : chr NA NA NA "+/-" ... ## $ X__25 : chr NA NA "Transport individuel motorisé" "[min.]" ... ## $ X__26 : chr NA NA NA "+/-" ... ## $ X__27 : chr NA NA "Transports publics" "[min.]" ... ## $ X__28 : chr NA NA NA "+/-" ... ## $ X__29 : chr NA "Durée moyenne des déplacements (avec les temps d'attente et de correspondance)" "Total" "[min.]" ... ## $ X__30 : chr NA NA NA "+/-" ... ## $ X__31 : chr NA NA "Travail" "[min.]" ... ## $ X__32 : chr NA NA NA "+/-" ... ## $ X__33 : chr NA NA "Loisirs" "[min.]" ... ## $ X__34 : chr NA NA NA "+/-" ... ## $ X__35 : chr NA "Nombre d'étapes par jour" "Total" "[nombre]" ... ## $ X__36 : chr NA NA NA "+/-" ... ## $ X__37 : chr NA NA "Mobilité douce" "[nombre]" ... ## $ X__38 : chr NA NA NA "+/-" ... ## $ X__39 : chr NA NA "Transport individuel motorisé" "[nombre]" ... ## $ X__40 : chr NA NA NA "+/-" ... ## $ X__41 : chr NA NA "Transports publics" "[nombre]" ... ## $ X__42 : chr NA NA NA "+/-" ... ## $ X__43 : chr NA NA "Travail" "[nombre]" ... ## $ X__44 : chr NA NA NA "+/-" ... ## $ X__45 : chr NA NA "Loisirs" "[nombre]" ... ## $ X__46 : chr NA NA NA "+/-" ... ## $ X__47 : chr NA "Nombre de déplacements par jour" "Total" "[nombre]" ... ## $ X__48 : chr NA NA NA "+/-" ... ## $ X__49 : chr NA NA "Travail" "[nombre]" ... ## $ X__50 : chr NA NA NA "+/-" ... ## $ X__51 : chr NA NA "Loisirs" "[nombre]" ... ## $ X__52 : chr NA NA NA "+/-" ... ## $ X__53 : chr NA "Nombre de boucles par jour" "Total" "[nombre]" ... ## $ X__54 : chr NA NA NA "+/-" ...
Le résultat n'est pas directement exploitable, et ce sera souvent le cas au moment de récupérer des fichiers publics, souvent structurés pour la lecture et pas pour une exploitation automatique.
Important : les fonctions utilisées traditionnellement pour importer des tableaux (par ex. read.table) importent par défaut les variables au format "factor", un concept spécifique à R et aux langages prévus pour faire des statistiques. Ce format s'emploie principalement lorsqu'une variable est catégorielle ordinale, c'est-à-dire que les valeurs qu'elle peut prendre sont parmi un ensemble de "mots" (catégorielle) et qu'on peut les classer (ordinale), par exemple l'ensemble : "très mauvais", "mauvais", "bon", "très bon".
Pour obtenir ce résultat, il faut utiliser (quand elle est disponible) l'option stringsAsFactors = TRUE qui est généralement vraie («TRUE») par défaut.
Le même genre de technique peut être utilisé pour lire des fichiers aux formats suivants.
| but | fonction |
|---|---|
| pur texte | read_file, read_lines |
| png | readPNG |
| spss | package haven |
| json | package jsonlite |
| xml | package xml2 |
Le traitement de données
Les data frames sont un des formats les plus importants et les plus populaires de R.
Il s'agit d'un tableau de données, qu'il ne faut pas confondre avec les formats matrix et table.
Tous les éléments d'une matrice sont du même type.
m1 <- matrix(c(1, 2, 3, 4), ncol = 2) m1
## [,1] [,2] ## [1,] 1 3 ## [2,] 2 4
Ici ce sont tous des nombres.
str(m1)
## num [1:2, 1:2] 1 2 3 4
Mais si on glisse des lettres dans la liste…
m2 <- matrix(c(1, "b", "c", 4), ncol = 2) m2
## [,1] [,2] ## [1,] "1" "c" ## [2,] "b" "4"
Les éléments numériques sont devenus des chaînes de caractères.
str(m2)
## chr [1:2, 1:2] "1" "b" "c" "4"
Il se passe quelque chose d'équivalent avec les vecteurs.
v1 <- c(1, 2, 3) v1
## [1] 1 2 3
v2 <- c(1, "b", 3) v2
## [1] "1" "b" "3"
En les comparant…
str(v1)
## num [1:3] 1 2 3
str(v2)
## chr [1:3] "1" "b" "3"
Le format table quand à lui est utilisé pour donner des tables de contingence.
Dans cet exemple, on tire 20 fois un dé 6.
dist <- round(runif(20, min = 1, max = 6)) dist
## [1] 4 3 4 4 6 3 2 6 5 4 5 5 4 6 3 4 2 3 4 6
On regroupe les résultats les résultats.
table(dist)
## dist ## 2 3 4 5 6 ## 2 4 7 3 4
Un data frame est un tableau avec des observations en ligne et des variables en colonne. Les variables peuvent être de tout type (numériques, ordinales, catégorielles, dates, etc.).
Manipuler un data frame
On reprend le tableau de données des retards de bus vu précédemment.
Un aperçu rapide.
head(retards)
## # A tibble: 6 x 60 ## Mois `Citadine Tourcoing` `Citadine Roubaix` `Citadine Lille` ## <chr> <dbl> <dbl> <dbl> ## 1 08. Aout 106 65 91 ## 2 09. Septembre 109 93 148 ## 3 10. Octobre 102 93 95 ## 4 11. Novembre 109 117 109 ## 5 03. Mars 104 123 83 ## 6 07. Juillet 141 81 76 ## # ... with 56 more variables: MWR <dbl>, COR <dbl>, `Citadine ## # Armentières` <dbl>, `Citadine Halluin` <chr>, L1 <dbl>, L2 <dbl>, ## # L3 <dbl>, L4 <dbl>, L90 <dbl>, L91 <dbl>, Z1 <chr>, Z2 <dbl>, ## # Z3 <dbl>, Z4 <dbl>, `10` <dbl>, `11` <dbl>, `12` <dbl>, `13` <dbl>, ## # `14` <dbl>, `15` <dbl>, `16` <dbl>, `17` <dbl>, `18` <dbl>, ## # `30` <dbl>, `32` <dbl>, `33` <dbl>, `35` <dbl>, `36` <dbl>, ## # `37` <dbl>, `50` <dbl>, `51` <dbl>, `52` <dbl>, `53` <dbl>, ## # `54` <dbl>, `55` <dbl>, `57` <dbl>, `58` <dbl>, `59` <dbl>, ## # `56` <dbl>, `61` <dbl>, `63` <dbl>, `64` <dbl>, `65` <dbl>, ## # `66` <dbl>, `67` <dbl>, `75` <dbl>, `76` <dbl>, `78` <dbl>, ## # `79` <dbl>, `80` <dbl>, `81` <dbl>, `82` <dbl>, `84` <dbl>, ## # `86` <dbl>, `87` <dbl>, `88` <dbl>
Comment accéder à une entrée (ligne).
retards[1,]
## # A tibble: 1 x 60 ## Mois `Citadine Tourcoing` `Citadine Roubaix` `Citadine Lille` MWR ## <chr> <dbl> <dbl> <dbl> <dbl> ## 1 08. Aout 106 65 91 211 ## # ... with 55 more variables: COR <dbl>, `Citadine Armentières` <dbl>, ## # `Citadine Halluin` <chr>, L1 <dbl>, L2 <dbl>, L3 <dbl>, L4 <dbl>, ## # L90 <dbl>, L91 <dbl>, Z1 <chr>, Z2 <dbl>, Z3 <dbl>, Z4 <dbl>, ## # `10` <dbl>, `11` <dbl>, `12` <dbl>, `13` <dbl>, `14` <dbl>, ## # `15` <dbl>, `16` <dbl>, `17` <dbl>, `18` <dbl>, `30` <dbl>, ## # `32` <dbl>, `33` <dbl>, `35` <dbl>, `36` <dbl>, `37` <dbl>, ## # `50` <dbl>, `51` <dbl>, `52` <dbl>, `53` <dbl>, `54` <dbl>, ## # `55` <dbl>, `57` <dbl>, `58` <dbl>, `59` <dbl>, `56` <dbl>, ## # `61` <dbl>, `63` <dbl>, `64` <dbl>, `65` <dbl>, `66` <dbl>, ## # `67` <dbl>, `75` <dbl>, `76` <dbl>, `78` <dbl>, `79` <dbl>, ## # `80` <dbl>, `81` <dbl>, `82` <dbl>, `84` <dbl>, `86` <dbl>, ## # `87` <dbl>, `88` <dbl>
Comment accéder à une variable.
retards[,1] ## la première variable
## # A tibble: 11 x 1 ## Mois ## <chr> ## 1 08. Aout ## 2 09. Septembre ## 3 10. Octobre ## 4 11. Novembre ## 5 03. Mars ## 6 07. Juillet ## 7 02. Février ## 8 04. Avril ## 9 05. Mai ## 10 01. Janvier ## 11 06. Juin
De manière équivalente, si on a la connaissance de ladite variable.
retards$Mois
## [1] "08. Aout" "09. Septembre" "10. Octobre" "11. Novembre" ## [5] "03. Mars" "07. Juillet" "02. Février" "04. Avril" ## [9] "05. Mai" "01. Janvier" "06. Juin"
Comment réarranger le tableau en fonction des mois de l'année ?
retards <- retards[order(retards$Mois),] retards
## # A tibble: 11 x 60 ## Mois `Citadine Tourcoing` `Citadine Roubaix` `Citadine Lille` ## <chr> <dbl> <dbl> <dbl> ## 1 01. Janvier 141 163 66 ## 2 02. Février 126 142 95 ## 3 03. Mars 104 123 83 ## 4 04. Avril 92 89 78 ## 5 05. Mai 94 11 73 ## 6 06. Juin 157 110 106 ## 7 07. Juillet 141 81 76 ## 8 08. Aout 106 65 91 ## 9 09. Septembre 109 93 148 ## 10 10. Octobre 102 93 95 ## 11 11. Novembre 109 117 109 ## # ... with 56 more variables: MWR <dbl>, COR <dbl>, `Citadine ## # Armentières` <dbl>, `Citadine Halluin` <chr>, L1 <dbl>, L2 <dbl>, ## # L3 <dbl>, L4 <dbl>, L90 <dbl>, L91 <dbl>, Z1 <chr>, Z2 <dbl>, ## # Z3 <dbl>, Z4 <dbl>, `10` <dbl>, `11` <dbl>, `12` <dbl>, `13` <dbl>, ## # `14` <dbl>, `15` <dbl>, `16` <dbl>, `17` <dbl>, `18` <dbl>, ## # `30` <dbl>, `32` <dbl>, `33` <dbl>, `35` <dbl>, `36` <dbl>, ## # `37` <dbl>, `50` <dbl>, `51` <dbl>, `52` <dbl>, `53` <dbl>, ## # `54` <dbl>, `55` <dbl>, `57` <dbl>, `58` <dbl>, `59` <dbl>, ## # `56` <dbl>, `61` <dbl>, `63` <dbl>, `64` <dbl>, `65` <dbl>, ## # `66` <dbl>, `67` <dbl>, `75` <dbl>, `76` <dbl>, `78` <dbl>, ## # `79` <dbl>, `80` <dbl>, `81` <dbl>, `82` <dbl>, `84` <dbl>, ## # `86` <dbl>, `87` <dbl>, `88` <dbl>
La fonction order appliquée à retards$Mois permet de classer les mois dans l'ordre donné par les chaîne de caractère 01 à 11.
Ensuite, placé avant la virgule, order(retards$Mois) signifie que nous réarrangeons l'ordre des lignes du tableau. L'effet s'applique sur les lignes entières, et pas uniquement sur les cases de la colonne concernée.
Nous allons voir dans la prochaine partie comment faire des visualisations à partir d'un tableau de données.
Pour aller plus loin, un tutorial est disponible ici
http://www.cookbook-r.com/Manipulating_data/
Un autre ici
http://tutorials.iq.harvard.edu/R/Rgraphics/Rgraphics.html
et des exercices ici
https://www.datacamp.com/community/tutorials/15-easy-solutions-data-frame-problems-r
Pour apprendre à manipuler correctement un ou plusieurs tableaux de données, créer et transformer des variables, sélectionner des sous-ensembles, le package dplyr est chaudement recommandé.
https://cran.r-project.org/web/packages/dplyr/vignettes/dplyr.html
Une cheatsheet est également disponible.
https://github.com/rstudio/cheatsheets/raw/master/data-transformation.pdf
La visualisation de données
ggplot2 met en pratique la grammaire des graphiques, une théorie de Leland Wilkinson (1999).
Setup.
if (!require(ggplot2)) install.packages("ggplot2")
## Loading required package: ggplot2
library(ggplot2)
if (!require(RColorBrewer)) install.packages("RColorBrewer")
## Loading required package: RColorBrewer
library(RColorBrewer)
Un jeu de données interne à ggplot2
Nous utilisons un jeu de données interne à ggplot2 contenant le prix ainsi que d'autres attributs de 53 940 diamants.
Les commandes suivantes permettent de prendre connaissance du jeu de données.
## help(diamonds) ## View(diamonds)
head(diamonds)
## # A tibble: 6 x 10 ## carat cut color clarity depth table price x y z ## <dbl> <ord> <ord> <ord> <dbl> <dbl> <int> <dbl> <dbl> <dbl> ## 1 0.23 Ideal E SI2 61.5 55 326 3.95 3.98 2.43 ## 2 0.21 Premium E SI1 59.8 61 326 3.89 3.84 2.31 ## 3 0.23 Good E VS1 56.9 65 327 4.05 4.07 2.31 ## 4 0.29 Premium I VS2 62.4 58 334 4.20 4.23 2.63 ## 5 0.31 Good J SI2 63.3 58 335 4.34 4.35 2.75 ## 6 0.24 Very Good J VVS2 62.8 57 336 3.94 3.96 2.48
str(diamonds)
## Classes 'tbl_df', 'tbl' and 'data.frame': 53940 obs. of 10 variables: ## $ carat : num 0.23 0.21 0.23 0.29 0.31 0.24 0.24 0.26 0.22 0.23 ... ## $ cut : Ord.factor w/ 5 levels "Fair"<"Good"<..: 5 4 2 4 2 3 3 3 1 3 ... ## $ color : Ord.factor w/ 7 levels "D"<"E"<"F"<"G"<..: 2 2 2 6 7 7 6 5 2 5 ... ## $ clarity: Ord.factor w/ 8 levels "I1"<"SI2"<"SI1"<..: 2 3 5 4 2 6 7 3 4 5 ... ## $ depth : num 61.5 59.8 56.9 62.4 63.3 62.8 62.3 61.9 65.1 59.4 ... ## $ table : num 55 61 65 58 58 57 57 55 61 61 ... ## $ price : int 326 326 327 334 335 336 336 337 337 338 ... ## $ x : num 3.95 3.89 4.05 4.2 4.34 3.94 3.95 4.07 3.87 4 ... ## $ y : num 3.98 3.84 4.07 4.23 4.35 3.96 3.98 4.11 3.78 4.05 ... ## $ z : num 2.43 2.31 2.31 2.63 2.75 2.48 2.47 2.53 2.49 2.39 ...
On ne va pas garder l'entier du tableau de données, mais seulement un échantillon, afin de ne pas surcharger ce notebook.
diam <- diamonds[sample(1:nrow(diamonds), 1000),]
Charger les données dans ggplot
Remarque : à partir d'ici, nous parlons principalement de ggplot sans le "2" car il va s'agir de la fonction "ggplot".
Le "2" n'est utilisé que dans le nom du package.
ggplot1 existe.
On charge les données
Attention ! L'input doit toujours être un data frame !
g <- ggplot(diam)
g
Contrairement à la fonction plot, qui bricole un visuel lorsqu'on entre la commande plot(diamonds), avec ggplot il ne se passe rien.
Juste un grand carré gris.
Le résultat avec le package base.
## plot(diamonds)
La commande de base plot(diamonds) considère toutes les variables du data frame et les croise entre elles - numériques comme ordinales - pour un résultat illisible et inutile.
Qu'obtient-on avec la commande ggplot ?
str(g)
## List of 9 ## $ data :Classes 'tbl_df', 'tbl' and 'data.frame': 1000 obs. of 10 variables: ## ..$ carat : num [1:1000] 0.7 0.4 0.73 1.01 0.32 0.31 0.3 1.13 0.31 0.38 ... ## ..$ cut : Ord.factor w/ 5 levels "Fair"<"Good"<..: 5 5 5 5 5 5 5 4 3 3 ... ## ..$ color : Ord.factor w/ 7 levels "D"<"E"<"F"<"G"<..: 1 5 2 6 3 1 4 5 3 1 ... ## ..$ clarity: Ord.factor w/ 8 levels "I1"<"SI2"<"SI1"<..: 3 4 6 3 4 4 6 1 4 4 ... ## ..$ depth : num [1:1000] 61.4 61.6 62 62.5 62.8 61.3 61.6 62.7 63 58.7 ... ## ..$ table : num [1:1000] 57 57 57 56 53 57 57 59 57 61 ... ## ..$ price : int [1:1000] 2699 800 3714 5020 828 734 655 3480 583 871 ... ## ..$ x : num [1:1000] 5.68 4.71 5.79 6.4 4.38 4.37 4.28 6.58 4.27 4.74 ... ## ..$ y : num [1:1000] 5.72 4.74 5.73 6.36 4.34 4.4 4.32 6.63 4.33 4.77 ... ## ..$ z : num [1:1000] 3.5 2.91 3.57 3.99 2.74 2.69 2.65 4.14 2.71 2.79 ... ## $ layers : list() ## $ scales :Classes 'ScalesList', 'ggproto' <ggproto object: Class ScalesList> ## add: function ## clone: function ## find: function ## get_scales: function ## has_scale: function ## input: function ## n: function ## non_position_scales: function ## scales: NULL ## super: <ggproto object: Class ScalesList> ## $ mapping : list() ## $ theme : list() ## $ coordinates:Classes 'CoordCartesian', 'Coord', 'ggproto' <ggproto object: Class CoordCartesian, Coord> ## aspect: function ## distance: function ## expand: TRUE ## is_linear: function ## labels: function ## limits: list ## range: function ## render_axis_h: function ## render_axis_v: function ## render_bg: function ## render_fg: function ## train: function ## transform: function ## super: <ggproto object: Class CoordCartesian, Coord> ## $ facet :Classes 'FacetNull', 'Facet', 'ggproto' <ggproto object: Class FacetNull, Facet> ## compute_layout: function ## draw_back: function ## draw_front: function ## draw_labels: function ## draw_panels: function ## finish_data: function ## init_scales: function ## map: function ## map_data: function ## params: list ## render_back: function ## render_front: function ## render_panels: function ## setup_data: function ## setup_params: function ## shrink: TRUE ## train: function ## train_positions: function ## train_scales: function ## vars: function ## super: <ggproto object: Class FacetNull, Facet> ## $ plot_env :<environment: R_GlobalEnv> ## $ labels : list() ## - attr(*, "class")= chr [1:2] "gg" "ggplot"
On retrouve le data frame contenant nos données, ainsi que les différents éléments propres à l'approche grammaticale des graphiques proposée par ggplot2, pour l'instant vides :
layers
scales
mapping
theme
coordinates
facet
À ce stade, le graphe est vide car nous n'avons défini ni mapping ni géométries (voir figure suivante).
g <- ggplot(diam) g
Mapping
Avec un mapping mais sans géométrie
cf. figure suivante.
Pour rappel : 'carat' et 'price' sont des variables continues.
ggplot(diam, aes(x = carat, y = price))
On remarque que les échelles et les labels des axes sont déjà posés.
ggplot attend maintenant de savoir quoi dessiner.
Avec une géométrie mais sans mapping
Pas de figure…
ggplot(diam) + geom_point()
## Error: geom_point requires the following missing aesthetics: x, y
Cette fois, ggplot n'a pas trouvé de mapping lui indiquant où poser son dessin, d'où l'erreur.
Avec un mapping et une géométrie
ggplot(diam, aes(x = carat, y = price)) + geom_point()
Pour comparaison, la commande la plus simple permettant d'obtenir (à peu près) le même résultat avec le package de base.
plot(diam$carat, diam$price)
Les échelles sont justes et les points sont bien situés, mais c'est tout et c'est moche.
C'est là le principe de ggplot : à partir de maintenant nous pouvons faire varier les éléments graphiques sans avoir à toucher aux données.
Par exemple, une interpolation.
ggplot(diam, aes(x = carat, y = price)) + geom_smooth()
## `geom_smooth()` using method = 'gam'
Superposer des layers
Il suffit de les additionner pour les superposer.
Attention au '+' à mettre à la fin de la ligne et pas au début.
ggplot(diam, aes(x = carat, y = price)) + geom_point() + geom_smooth()
## `geom_smooth()` using method = 'gam'
Attention, l'ordre des géométries a une influence sur le graphique !
ggplot(diam, aes(x = carat, y = price)) + geom_smooth() + geom_point()
## `geom_smooth()` using method = 'gam'
Dans le graphique précédent, la courbe d'interpolation a été dessinée avant les points.
Ainsi, elle apparaît dans la figure cachée sous ces derniers.
Différents mappings
Le mapping peut se faire à plusieurs endroits :
Dans
ggplot(), ce qui a pour effet d'appliquer le mapping à tous les autres éléments.Dans les éléments graphiques eux-mêmes.
Tout dans ggplot
ggplot(diam, aes(x = carat, y = price)) + geom_point()
Dans les deux
ggplot(diam, aes(x = carat)) + geom_point(aes(y = price))
Tout dans la géométrie
ggplot(diam) + geom_point(aes(x = carat, y = price))
Bref, on peut mapper de nombreuses variables, en une seule fois, directement dans ggplot et elles seront reprises par les autres éléments.
Par exemple, l'attribut color de geom_point.
Remarque : la variable 'clarity' est ordinale.
ggplot(diam, aes(x = carat, y = price, color = clarity)) + geom_point()
Grâce à ce seul mapping, ggplot attribue à chaque modalité une couleur, attribue aux points la couleur correspondante, et génère dans la foulée une légende (une des angoisses lorsqu'on travaille avec les commandes de base).
Pour l'anecdote, nous aurions obtenu le même résultat en faisant le mapping dans geom_point.
ggplot(diam, aes(x = carat, y = price)) + geom_point(aes(color = clarity))
Attention à ne pas oublier de faire le mapping, c'est-à-dire d'utiliser la fonction aes(), sinon ça ne fonctionnera pas !
ggplot(diam, aes(x = carat, y = price)) + geom_point(color = clarity)
## Error in layer(data = data, mapping = mapping, stat = stat, geom = GeomPoint, : object 'clarity' not found
On trouve toutes les géométries disponibles ainsi que de nombreuses autres ressources indispensables dans l'indispensable cheat sheet de ggplot2 !
Variables et transformations, discrètes et continues
C'est hasardeux, mais on peut également appliquer une transformation continue (size) à une variable ordinale (cut).
ggplot(diam, aes(x = carat, y = price, color = clarity, size = cut)) + geom_point()
## Warning: Using size for a discrete variable is not advised.
Toutefois, il est recommandé d'appliquer une transformation continue (size) à une variable continue (par exemple depth) et une transformation discrète comme la couleur ou la forme (shape) à une variable discrète (par exemple cut).
ggplot(diam, aes(x = carat, y = price, color = clarity, shape = cut)) + geom_point()
Détail qui a son importance dans l'exemple suivant : la fonction geom_smooth va hériter du mapping sur la couleur.
Note : "se = FALSE" empêche l'affichage de l'incertitude.
ggplot(diam, aes(x = carat, y = price, color = clarity)) + geom_point() + geom_smooth(se = FALSE)
## `geom_smooth()` using method = 'loess'
Pour le mapping sur la forme (au lieu de la couleur), on repassera.
ggplot(diam, aes(x = carat, y = price, shape = cut)) + geom_point() + geom_smooth(se = FALSE)
## `geom_smooth()` using method = 'loess'
Et si l'on prend en considération les deux en même temps, ça peut mener à la catastrophe.
ggplot(diam, aes(x = carat, y = price, color = clarity, shape = cut)) + geom_point() + geom_smooth(se = FALSE)
## `geom_smooth()` using method = 'loess'
## Warning in simpleLoess(y, x, w, span, degree = degree, parametric = ## parametric, : span too small. fewer data values than degrees of freedom.
## Warning in simpleLoess(y, x, w, span, degree = degree, parametric = ## parametric, : at 0.9573
## Warning in simpleLoess(y, x, w, span, degree = degree, parametric = ## parametric, : radius 7.29e-06
## Warning in simpleLoess(y, x, w, span, degree = degree, parametric = ## parametric, : all data on boundary of neighborhood. make span bigger
## Warning in simpleLoess(y, x, w, span, degree = degree, parametric = ## parametric, : pseudoinverse used at 0.9573
## Warning in simpleLoess(y, x, w, span, degree = degree, parametric = ## parametric, : neighborhood radius 0.0027
## Warning in simpleLoess(y, x, w, span, degree = degree, parametric = ## parametric, : reciprocal condition number 1
## Warning in simpleLoess(y, x, w, span, degree = degree, parametric = ## parametric, : at 1.5027
## Warning in simpleLoess(y, x, w, span, degree = degree, parametric = ## parametric, : radius 7.29e-06
## Warning in simpleLoess(y, x, w, span, degree = degree, parametric = ## parametric, : all data on boundary of neighborhood. make span bigger
## Warning in simpleLoess(y, x, w, span, degree = degree, parametric = ## parametric, : There are other near singularities as well. 7.29e-06
## Warning in simpleLoess(y, x, w, span, degree = degree, parametric = ## parametric, : zero-width neighborhood. make span bigger ## Warning in simpleLoess(y, x, w, span, degree = degree, parametric = ## parametric, : zero-width neighborhood. make span bigger
## Warning: Computation failed in `stat_smooth()`: ## NA/NaN/Inf in foreign function call (arg 5)
Le même code que précédemment, avec cette fois le graphique à la place du message d'erreur.
ggplot(diam, aes(x = carat, y = price, color = clarity, shape = cut)) + geom_point() + geom_smooth(se = FALSE)
## `geom_smooth()` using method = 'loess'
Il est nécessaire de redistribuer le mapping plus subtilement.
ggplot(diam, aes(x = carat, y = price, color = clarity)) + geom_point(aes(shape = cut)) + geom_smooth(se = FALSE)
## `geom_smooth()` using method = 'loess'
D'autres exemples concernant les attributs des éléments géométriques.
Transformation continue, variable continue
ggplot(diam, aes(x = carat, y = price, color = clarity, size = depth)) + geom_point()
Il est possible évidemment de modifier plus subtilement la taille des sommets lorsqu'on fait un mapping dessus, si les valeurs par défaut ne nous plaisent pas.
En général, cela passe par les fonctions scale.
Elles commencent par scale_ (voir la cheat sheet).
Nous reviendrons plus en détail là-dessus.
Dans la figure suivante, nous donnons des valeurs minimales et maximales pour la taille des sommets.
ggplot(diam, aes(x = carat, y = price, color = clarity, size = depth)) + geom_point() + scale_size(range = c(1,3))
Remarque : l'effet est difficile à observer car la variance est très petite.
summary(diam$depth)
## Min. 1st Qu. Median Mean 3rd Qu. Max. ## 57.00 61.00 61.80 61.72 62.50 67.60
sd(diam$depth)
## [1] 1.290078
Au passage, remarquons que l'on peut aussi utiliser l'attribut size de geom_point sans mapping.
ggplot(diam, aes(x = carat, y = price, color = clarity)) + geom_point(size = 1)
Dans ce cas, la taille des points est considérée hors mapping et donc indépendamment d'une quelconque variable.
Remarquons également l'organisation hiérarchique des mappings et des transformations : dans l'exemple qui suit, la variable depth est tout d'abord mappée sur la taille des sommets.
Puis, dans geom_point, on lui attribue une valeur fixe.
Arrivée ensuite, c'est cette dernière qui l'emporte sur le mapping initial.
ggplot(diam, aes(x = carat, y = price, color = clarity, size = depth)) + geom_point(size = 1)
Au passage, la modification du titre en légende dépend de la fonction scale correspondante (ici scale_size).
C'est logique, mais contre-intuitif pour qui aura passé beaucoup (trop ?) de temps avec les commandes graphiques de base dans R.
ggplot(diam, aes(x = carat, y = price, color = clarity, size = depth)) +
geom_point() +
scale_size("DEPTH", range = c(1,3))
Bilan intermédiaire
Nous avons vu comment :
Charger les données.
Faire un mapping.
Superposer une ou plusieurs géométries.
Il nous reste à découvrir :
Le facettage.
Les échelles.
Les annotations.
Les types de graphiques autres que les scatterplots.
Comment sauver un graphique.
Comment bien préparer ses données.
Le facettage
Attention ! Ceci s'applique à des variables discrètes.
Le facettage divise le jeu de données en fonction des catégories d'une variable.
Dans un sens…
ggplot(diam, aes(x = carat, y = price)) + geom_point() + facet_grid(. ~ cut)
… et dans l'autre.
(Remarquez la position inversée de la variable cut dans facet_grid().)
ggplot(diam, aes(x = carat, y = price)) + geom_point() + facet_grid(cut ~ .)
En croisant deux variables discrètes.
ggplot(diam, aes(x = carat, y = price)) + geom_point() + facet_grid(color ~ clarity)
Finalement, en croisant deux variables discrètes, avec un mapping sur la couleur.
ggplot(diam, aes(x = carat, y = price, color = cut)) + geom_point() + facet_grid(color ~ clarity)
Il y a une autre option de facettage lorsqu'on n'utilise qu'une seule variable discrète : facet_wrap.
Dans ce cas, remarquez que nous n'utilisons plus le point (.) avant le tilde (~).
ggplot(diam, aes(x = carat, y = price)) + geom_point() + facet_wrap(~ clarity)
Les échelles
Elles commencent toutes par scale_
Ensuite, on complète avec le nom de la variable concernée.
scale_alpha scale_alpha_continuous scale_alpha_discrete scale_alpha_identity scale_alpha_manual scale_color_brewer scale_color_continuous scale_color_discrete scale_color_distiller scale_color_gradient scale_color_gradient2 scale_color_gradientn scale_color_grey scale_color_hue scale_color_identity scale_color_manual scale_colour_brewer scale_colour_continuous scale_colour_date scale_colour_datetime scale_colour_discrete scale_colour_distiller scale_colour_gradient scale_colour_gradient2 scale_colour_gradientn scale_colour_grey scale_colour_hue scale_colour_identity scale_colour_manual scale_continuous scale_date scale_fill_brewer scale_fill_continuous scale_fill_date scale_fill_datetime scale_fill_discrete scale_fill_distiller scale_fill_gradient scale_fill_gradient2 scale_fill_gradientn scale_fill_grey scale_fill_hue scale_fill_identity scale_fill_manual scale_identity scale_linetype scale_linetype_continuous scale_linetype_discrete scale_linetype_identity scale_linetype_manual scale_manual scale_radius scale_shape scale_shape_continuous scale_shape_discrete scale_shape_identity scale_shape_manual scale_size scale_size_area scale_size_continuous scale_size_date scale_size_datetime scale_size_discrete scale_size_identity scale_size_manual scale_x_continuous scale_x_date scale_x_datetime scale_x_discrete scale_x_log10 scale_x_reverse scale_x_sqrt scale_y_continuous scale_y_date scale_y_datetime scale_y_discrete scale_y_log10 scale_y_reverse scale_y_sqrt
Par exemple, si l'on travaille sur la couleur, on pourra faire varier la palette des couleurs en modifiant le nom de l'échelle. Faites le test en écrivant scale_color_ dans la console puis en pressant sur la touche tab pour voir les suggestions…
En gris
ggplot(diam, aes(x = carat, y = price, color = clarity)) + geom_point() + scale_color_grey()
La version par défaut.
ggplot(diam, aes(x = carat, y = price, color = clarity)) + geom_point() + scale_color_discrete()
ColorBrewer, nommée d'après une de ses auteurs, Cnythia Brewer, est une librairie de couleurs précalculées qui s'accordent bien.
On peut les utiliser ici avec la fonction scale_color_brewer.
ggplot(diam, aes(x = carat, y = price, color = clarity)) + geom_point() + scale_color_brewer()
En changeant de palette.
ggplot(diam, aes(x = carat, y = price, color = clarity)) + geom_point() + scale_color_brewer(palette = 2)
Attention si vous utilisez la mauvaise échelle : soit il ne se passera rien (comme dans la figure suivante), soit il y aura un message d'erreur.
ggplot(diam, aes(x = carat, y = price, color = clarity)) + geom_point() + scale_fill_brewer(palette = 2)
Dans la figure suivante, nous changeons la forme utilisée pour dessiner les points afin qu'il y ait un pourtour (color) et un contenu (fill).
Cette transformation a été effectuée en donnant comme instruction que les points doivent changer de forme (indépendamment de toute variable).
Nous en profitons pour dessiner l'intérieur. Quelle fonction faut-il utiliser ?
ggplot(diam, aes(x = carat, y = price, fill = clarity)) + geom_point(shape = 21) + scale_fill_brewer(palette = 2)
Mais les échelles, ça ne concerne pas seulement l'intérieur du graphique.
Nous utilisons également des échelles sur les axes.
ggplot(diam, aes(x = carat, y = price, color = clarity)) + geom_point() + scale_x_continuous(breaks = c(1,3), minor_breaks = c(sqrt(2), pi)) + scale_y_continuous(breaks = sample(20000, 10))
Échelle logarithmique FTW.
ggplot(diam, aes(x = carat, y = price, color = clarity)) + geom_point() + scale_y_log10()
Les annotations
Via un mapping, par exemple pour un MDS.
ggplot(diam, aes(x = carat, y = price, label = clarity)) + geom_text()
L'annotation manuelle est possible, à l'ancienne, mais pas forcément recommandée.
ggplot(diam, aes(x = carat, y = price, color = clarity)) +
geom_point() +
annotate("text", x = 3.5, y = 10000, label = "HELLO")
D'autres types de graphiques
C'est la seule fois que nous voyons une transformation statistique dans cette présentation (malheureusement).
Ce sont les fonctions commençant par stat_.
Pour plus d'infos, voir la cheat sheet.
ggplot(diam, aes(price)) + geom_area(stat = "bin")
## `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
ggplot(diam, aes(price)) + geom_density(kernel = "gaussian")
ggplot(diam, aes(price)) + geom_histogram(binwidth = 30)
Avec une variable discrète, cette fois.
ggplot(diam, aes(color)) + geom_bar()
Une variable discrète et une variable continue.
ggplot(diam, aes(x = color, y = price)) + geom_boxplot()
Deux variables discrètes.
ggplot(diam, aes(x = cut, y = color)) + geom_count()
ggplot(diamonds, aes(x=price, fill=cut)) + geom_histogram()
## `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
Distributions bi-variées.
ggplot(diamonds, aes(carat, price)) + geom_bin2d(binwidth = c(0.25, 500))
ggplot(diamonds, aes(carat, price)) + geom_hex()
Les thèmes
La fonction ggtitle est utilisée pour choisir un titre.
ggplot(diam, aes(x = carat, y = price, color = clarity)) +
geom_point() +
ggtitle("Mon joli graphique")
Et, classique pour une fois, xlab et ylab pour changer les noms des axes.
ggplot(diam, aes(x = carat, y = price, color = clarity)) +
geom_point() +
xlab("Ma jolie abscisse") +
ylab("Ma jolie ordonnée")
Pour varier les thèmes : theme_.
ggplot(diam, aes(x = carat, y = price, color = clarity)) + geom_point() + theme_bw()
ggplot(diam, aes(x = carat, y = price, color = clarity)) + geom_point() + theme_dark()
ggplot(diam, aes(x = carat, y = price, color = clarity)) + geom_point() + theme_minimal()
Sauver un graphique
ggsave
## function (filename, plot = last_plot(), device = NULL, path = NULL,
## scale = 1, width = NA, height = NA, units = c("in", "cm",
## "mm"), dpi = 300, limitsize = TRUE, ...)
## {
## dev <- plot_dev(device, filename, dpi = dpi)
## dim <- plot_dim(c(width, height), scale = scale, units = units,
## limitsize = limitsize)
## if (!is.null(path)) {
## filename <- file.path(path, filename)
## }
## dev(file = filename, width = dim[1], height = dim[2], ...)
## on.exit(utils::capture.output(grDevices::dev.off()))
## grid.draw(plot)
## invisible()
## }
## <environment: namespace:ggplot2>
Par exemple
ggsave("plot.pdf", width = 7, height = 7)
Bien préparer ses données
«Tidy data is a standard way of mapping the meaning of a dataset to its structure.»
«A dataset is messy or tidy depending on how rows, columns and tables are matched up with observations, variables and types.»
«In tidy data:
- Each variable forms a column.
- Each observation forms a row.
- Each type of observational unit forms a table.»
Source :
# library(tidyr)
# vignette("tidy-data")
Marie-Louise Timcke a proposé sur journocode.com une très bonne ressource à ce sujet.
En particulier, elle présente l'exemple suivant, extrait d'explications d'Hadley Wickham.
Le format tidy, ou long form, est fortement recommandé dans ggplot2.